Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Handler = undefined;
var def_EventManager = function () {
  function _ctor() { }
  _ctor.on = function (t, e, o) {
    // 确保事件存在，如果不存在则初始化为空数组
    if (!(t in this.events)) {
      this.events[t] = [];
    }

    // 检查事件列表中是否已经存在相同的处理器
    for (let index = this.events[t].length - 1; index >= 0; --index) {
      if (this.events[t][index].equal(e, o)) {
        return null; // 如果已存在，直接返回 null
      }
    }

    // 创建新的处理器并添加到事件列表中
    const handler = new exp_Handler(e, o);
    this.events[t].push(handler);
    return handler;

  };
  _ctor.once = function (t, e, o) {
    // 确保事件存在，如果不存在则初始化为空数组
    if (!(t in this.onceEvents)) {
      this.onceEvents[t] = [];
    }

    // 检查事件列表中是否已经存在相同的处理器
    for (let index = this.onceEvents[t].length - 1; index >= 0; --index) {
      if (this.onceEvents[t][index].equal(e, o)) {
        return null; // 如果已存在，直接返回 null
      }
    }

    // 创建新的一次性处理器并添加到事件列表中
    const handler = new exp_Handler(e, o);
    this.onceEvents[t].push(handler);
    return handler;

  };
  _ctor.off = function (t, e, o) {
    // 如果没有传入参数 e，初始化事件数组并返回
    if (!e) {
      this.events[t] = [];
      this.onceEvents[t] = [];
      return;
    }

    // 定义一个函数用于从数组中移除处理器
    const removeHandler = (eventType, handlerId) => {
      if (this[eventType].hasOwnProperty(t)) {
        for (let index = this[eventType][t].length - 1; index >= 0; --index) {
          if (this[eventType][t][index].id === handlerId) {
            this[eventType][t].splice(index, 1);
            break; // 找到后退出循环
          }
        }
      }
    };

    // 如果 e 是 exp_Handler 实例，根据 id 移除
    if (e instanceof exp_Handler) {
      removeHandler('events', e.id);
      removeHandler('onceEvents', e.id);
    } else {
      // 根据等式移除处理器
      const equalHandler = (eventType) => {
        if (this[eventType].hasOwnProperty(t)) {
          for (let index = this[eventType][t].length - 1; index >= 0; --index) {
            if (this[eventType][t][index].equal(e, o)) {
              this[eventType][t].splice(index, 1);
              break; // 找到后退出循环
            }
          }
        }
      };

      equalHandler('events');
      equalHandler('onceEvents');
    }

  };
  _ctor.offGroup = function (t, e) {
    // 定义一个函数用于从事件数组中移除处理器
    const removeHandlers = (eventType) => {
      if (this[eventType].hasOwnProperty(t)) {
        for (let i = e.length - 1; i >= 0; --i) {
          const handlerId = e[i].id;
          for (let j = this[eventType][t].length - 1; j >= 0; --j) {
            if (this[eventType][t][j].id === handlerId) {
              this[eventType][t].splice(j, 1);
              break; // 找到后退出内层循环
            }
          }
        }
      }
    };

    // 从 events 和 onceEvents 中移除处理器
    removeHandlers('events');
    removeHandlers('onceEvents');

  };
  _ctor.emit = function (t, e, o, n, i, r) {
    // 定义一个函数用于执行事件的回调
    const executeCallbacks = (eventType, args) => {
      if (this[eventType].hasOwnProperty(t)) {
        const handlers = this[eventType][t];
        for (let index = 0; index < handlers.length; ++index) {
          handlers[index].cb.call(handlers[index].target, ...args);
        }
      }
    };

    // 构建参数数组，填充 undefined 处理
    const args = [e, o, n, i, r].filter(arg => arg !== undefined);

    // 执行 events 和 onceEvents 的回调
    executeCallbacks('events', args);
    executeCallbacks('onceEvents', args);

    // 删除 onceEvents 中的事件
    if (this.onceEvents.hasOwnProperty(t)) {
      delete this.onceEvents[t];
    }

  };
  _ctor.events = {};
  _ctor.onceEvents = {};
  return _ctor;
}();
exports.default = def_EventManager;
var exp_Handler = function () {
  function t(e, o) {
    this._id = t.idCount++;
    this.target = o;
    this.cb = e;
  }
  Object.defineProperty(t.prototype, "id", {
    get() {
      return this._id;
    },
    enumerable: false,
    configurable: true
  });
  t.prototype.equal = function (t, e) {
    return this.target === e && this.cb == t;
  };
  t.idCount = 0;
  return t;
}();
exports.Handler = exp_Handler;